Computer science
'
Answer
To tackle this project, you'll need to develop a `WordAnalysisADT` in Java that can efficiently handle the specified operations. Here's a structured approach to design and implement this ADT:
1. **Define the `WordAnalysisADT` class:**
- This class will contain methods to perform each of the specified operations.
- Use data structures like HashMap and HashSet to achieve efficient lookups and counting.
2. **Read and store the text file contents:**
- Read the text file line by line.
- Store the words and their occurrences in appropriate data structures.
3. **Operations Implementation:**
- **Total number of words:** Simply count the words as you parse the file.
- **Total number of unique words:** Use a HashSet to store unique words and then get its size.
- **Occurrences of a particular word:** Use a HashMap where the key is the word and the value is the count of occurrences.
- **Total number of words with a particular length:** Maintain a count of words based on their lengths in another HashMap.
- **Display unique words sorted by frequency:** Use a PriorityQueue or sort the entries of the HashMap.
- **Display locations of word occurrences:** Store positions (line and word index) in a list inside the HashMap.
- **Check adjacent word occurrences:** While parsing, keep track of word pairs and their occurrences.
Here's a basic implementation outline:
```java
import java.io.*;
import java.util.*;
public class WordAnalysisADT {
private List<String> lines;
private Map<String, Integer> wordCount;
private Map<String, List<Integer>> wordPositions;
private Map<Integer, Integer> lengthCount;
private Map<String, Set<Integer>> wordLineMap;
private Map<String, List<int[]>> wordAdjacencyMap;
public WordAnalysisADT(String filePath) throws IOException {
lines = new ArrayList<>();
wordCount = new HashMap<>();
wordPositions = new HashMap<>();
lengthCount = new HashMap<>();
wordLineMap = new HashMap<>();
wordAdjacencyMap = new HashMap<>();
readFile(filePath);
}
private void readFile(String filePath) throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(filePath));
String line;
int lineNum = 0;
while ((line = reader.readLine()) != null) {
lines.add(line);
String[] words = line.split("\\s+");
for (int i = 0; i < words.length; i++) {
String word = words[i].toLowerCase().replaceAll("[^a-zA-Z]", "");
wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
lengthCount.put(word.length(), lengthCount.getOrDefault(word.length(), 0) + 1);
if (!wordPositions.containsKey(word)) {
wordPositions.put(word, new ArrayList<>());
}
wordPositions.get(word).add(lineNum * 1000 + i);
if (i > 0) {
String prevWord = words[i - 1].toLowerCase().replaceAll("[^a-zA-Z]", "");
String pair = prevWord + " " + word;
wordAdjacencyMap.computeIfAbsent(pair, k -> new ArrayList<>()).add(new int[]{lineNum, i - 1});
}
wordLineMap.computeIfAbsent(word, k -> new HashSet<>()).add(lineNum);
}
lineNum++;
}
reader.close();
}
public int getTotalWords() {
return wordCount.values().stream().mapToInt(Integer::intValue).sum();
}
public int getUniqueWords() {
return wordCount.size();
}
public int getOccurrences(String word) {
return wordCount.getOrDefault(word.toLowerCase(), 0);
}
public int getWordsOfLength(int length) {
return lengthCount.getOrDefault(length, 0);
}
public List<Map.Entry<String, Integer>> getSortedUniqueWords() {
List<Map.Entry<String, Integer>> sortedList = new ArrayList<>(wordCount.entrySet());
sortedList.sort((a, b) -> b.getValue().compareTo(a.getValue()));
return sortedList;
}
public List<Integer> getWordPositions(String word) {
return wordPositions.getOrDefault(word.toLowerCase(), new ArrayList<>());
}
public boolean areWordsAdjacent(String word1, String word2) {
String pair = word1.toLowerCase() + " " + word2.toLowerCase();
return wordAdjacencyMap.containsKey(pair);
}
public static void main(String[] args) {
try {
WordAnalysisADT analysis = new WordAnalysisADT("textfile.txt");
System.out.println("Total Words: " + analysis.getTotalWords());
System.out.println("Unique Words: " + analysis.getUniqueWords());
System.out.println("Occurrences of 'the': " + analysis.getOccurrences("the"));
System.out.println("Words of length 3: " + analysis.getWordsOfLength(3));
System.out.println("Sorted Unique Words: " + analysis.getSortedUniqueWords());
System.out.println("Positions of 'data': " + analysis.getWordPositions("data"));
System.out.println("Are 'data' and 'structure' adjacent: " + analysis.areWordsAdjacent("data", "structure"));
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
### Explanation of the Code:
1. **Data Structures**:
- `wordCount`: A HashMap to store the count of each word.
- `wordPositions`: A HashMap to store the list of positions for each word.
- `lengthCount`: A HashMap to store the count of words by their length.
- `wordLineMap`: A HashMap to track the lines where each word occurs.
- `wordAdjacencyMap`: A HashMap to store adjacency information for word pairs.
2. **Methods**:
- `readFile()`: Reads the file and populates the data structures.
- `getTotalWords()`: Returns the total number of words.
- `getUniqueWords()`: Returns the number of unique words.
- `getOccurrences()`: Returns the occurrences of a specific word.
- `getWordsOfLength()`: Returns the count of words of a particular length.
- `getSortedUniqueWords()`: Returns a sorted list of unique words by their frequency.
- `getWordPositions()`: Returns the positions of a specific word.
- `areWordsAdjacent()`: Checks if two words occur adjacent to each other.
This implementation provides a foundation for the `WordAnalysisADT` class, fulfilling the project requirements as outlined in the prompt. Adjustments can be made based on specific performance needs or additional requirements.
To develop the text analysis tool in Java as described in the project, you need to design a WordAnalysis ADT to efficiently handle several operations. Here is a breakdown of what needs to be done:
### ADT Design
1. **Graphical Representation (Part a)**
- Design a data structure that can store words and their attributes.
- Possible data structures: HashMap for word occurrences, TreeMap for sorted word occurrences, or a Trie for prefix-based operations.
- Clearly label your diagram to show how words are stored and how the operations will interact with these structures.
2. **Explanation (Part b)**
- Write a detailed explanation of your design.
- Describe each component (e.g., nodes in a Trie, entries in a HashMap).
- Justify your choices based on the efficiency of operations and ease of implementation.
3. **Operation Specifications (Part c)**
- **Total number of words (Operation 1):**
- Traverse the text and count the words.
- Use a simple counter as you read words from the file.
- **Total number of unique words (Operation 2):**
- Use a HashSet to store unique words while reading the file.
- **Occurrences of a particular word (Operation 3):**
- Use a HashMap with words as keys and their counts as values.
- **Total number of words with a particular length (Operation 4):**
- Use an array or another HashMap where the key is the word length and the value is the count of words of that length.
- **Display unique words and their occurrences (Operation 5):**
- Traverse the HashMap and sort entries by values (occurrences) in descending order.
- **Display locations of occurrences of a word (Operation 6):**
- Use a HashMap where the key is the word and the value is a list of positions (line and word position) in the text.
- **Check if two words are adjacent (Operation 7):**
- Traverse the text and check consecutive word pairs, storing results in a structure that supports adjacency queries.
4. **Time Complexity Analysis (Part d)**
- **Operation 1:** \(O(n)\) where \(n\) is the number of words.
- **Operation 2:** \(O(n)\) insertion and lookup in HashSet.
- **Operation 3:** \(O(1)\) average-case for HashMap lookup.
- **Operation 4:** \(O(n)\) for counting word lengths.
- **Operation 5:** \(O(n \log n)\) for sorting word occurrences.
- **Operation 6:** \(O(n)\) for initial population, \(O(1)\) for lookup.
- **Operation 7:** \(O(n)\) to find and check adjacent words.
- Consider cases for evenly and unevenly distributed word lengths when analyzing time complexity for operations involving word lengths and unique words.
### Example Breakdown:
- **Example Text:**
```
"In computer science, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data."
```
- **Total words:** 28
- **Unique words:** 23
- **Occurrences of 'the':** 3
- **Words of length 2:** 6 (is, a, a, of, to, in)
- **Sorted unique words with occurrences:**
- the: 3, data: 3, (other words with their counts)
- **Occurrences of 'data':**
- Lines and positions: (1, 5), (1, 11), (2, 14)
- **'data' and 'the' adjacent:** True (check adjacency in text)
### Remarks:
- Ignore punctuation.
- Count hyphenated and apostrophized words as single words.
- Handle single letter words.
By structuring your ADT efficiently and considering the above points, you can ensure that your text analysis tool performs operations quickly and accurately.